home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / comm / mail / Mutt089src.lha / Mutt-0.89i-AMIGA / src / flags.c < prev    next >
C/C++ Source or Header  |  1998-01-28  |  5KB  |  294 lines
  1. /*
  2.  * Copyright (C) 1996-8 Michael R. Elkins <me@cs.hmc.edu>
  3.  * 
  4.  *     This program is free software; you can redistribute it and/or modify
  5.  *     it under the terms of the GNU General Public License as published by
  6.  *     the Free Software Foundation; either version 2 of the License, or
  7.  *     (at your option) any later version.
  8.  * 
  9.  *     This program is distributed in the hope that it will be useful,
  10.  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  *     GNU General Public License for more details.
  13.  * 
  14.  *     You should have received a copy of the GNU General Public License
  15.  *     along with this program; if not, write to the Free Software
  16.  *     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  */ 
  18.  
  19. #include "mutt.h"
  20. #include "mutt_curses.h"
  21. #include "sort.h"
  22.  
  23. void mutt_set_flag (CONTEXT *ctx, HEADER *h, int flag, int bf)
  24. {
  25.   int changed = h->changed;
  26.   int deleted = ctx->deleted;
  27.   int tagged = ctx->tagged;
  28.  
  29.   if (ctx->readonly && flag != M_TAG)
  30.     return; /* don't modify anything if we are read-only */
  31.  
  32.   switch (flag)
  33.   {
  34.     case M_DELETE:
  35.       if (bf)
  36.       {
  37.     if (!h->deleted)
  38.     {
  39.       h->deleted = 1;
  40.       ctx->deleted++;
  41.     }
  42.       }
  43.       else if (h->deleted)
  44.       {
  45.     h->deleted = 0;
  46.     ctx->deleted--;
  47.       }
  48.       break;
  49.  
  50.     case M_NEW:
  51.       if (bf)
  52.       {
  53.     if (h->read || h->old)
  54.     {
  55.       h->read = 0;
  56.       h->old = 0;
  57.       ctx->new++;
  58.       h->changed = 1;
  59.       ctx->changed = 1;
  60.     }
  61.       }
  62.       else if (!h->read)
  63.       {
  64.     if (!h->old)
  65.       ctx->new--;
  66.     h->read = 1;
  67.     h->changed = 1;
  68.     ctx->changed = 1;
  69.       }
  70.       break;
  71.  
  72.     case M_OLD:
  73.       if (bf)
  74.       {
  75.     if (!h->old)
  76.     {
  77.       h->old = 1;
  78.       if (!h->read)
  79.         ctx->new--;
  80.       h->changed = 1;
  81.       ctx->changed = 1;
  82.     }
  83.       }
  84.       else if (h->old)
  85.       {
  86.     h->old = 0;
  87.     if (!h->read)
  88.       ctx->new++;
  89.     h->changed = 1;
  90.     ctx->changed = 1;
  91.       }
  92.       break;
  93.  
  94.     case M_READ:
  95.       if (bf)
  96.       {
  97.     if (!h->read)
  98.     {
  99.       h->read = 1;
  100.       if (!h->old)
  101.         ctx->new--;
  102.       h->changed = 1;
  103.       ctx->changed = 1;
  104.     }
  105.       }
  106.       else if (h->read)
  107.       {
  108.     h->read = 0;
  109.     if (!h->old)
  110.       ctx->new++;
  111.     h->changed = 1;
  112.     ctx->changed = 1;
  113.       }
  114.       break;
  115.  
  116.     case M_REPLIED:
  117.       if (bf)
  118.       {
  119.     if (!h->replied)
  120.     {
  121.       h->replied = 1;
  122.       if (!h->read)
  123.       {
  124.         h->read = 1;
  125.         if (!h->old)
  126.           ctx->new--;
  127.       }
  128.       h->changed = 1;
  129.       ctx->changed = 1;
  130.     }
  131.       }
  132.       else if (h->replied)
  133.       {
  134.     h->replied = 0;
  135.     h->changed = 1;
  136.     ctx->changed = 1;
  137.       }
  138.       break;
  139.  
  140.     case M_FLAG:
  141.       if (bf)
  142.       {
  143.     if (!h->flagged)
  144.     {
  145.       h->flagged = bf;
  146.       ctx->flagged++;
  147.       h->changed = 1;
  148.       ctx->changed = 1;
  149.     }
  150.       }
  151.       else if (h->flagged)
  152.       {
  153.     h->flagged = 0;
  154.     ctx->flagged--;
  155.     h->changed = 1;
  156.     ctx->changed = 1;
  157.       }
  158.       break;
  159.  
  160.     case M_TAG:
  161.       if (bf)
  162.       {
  163.     if (!h->tagged)
  164.     {
  165.       h->tagged = 1;
  166.       ctx->tagged++;
  167.     }
  168.       }
  169.       else if (h->tagged)
  170.       {
  171.     h->tagged = 0;
  172.     ctx->tagged--;
  173.       }
  174.       break;
  175.   }
  176.  
  177.   /* if the message status has changed, we need to invalidate the cached
  178.    * search results so that any future search will match the current status
  179.    * of this message and not what it was at the time it was last searched.
  180.    */
  181.   if (h->searched && (changed != h->changed || deleted != ctx->deleted || tagged != ctx->tagged))
  182.     h->searched = 0;
  183. }
  184.  
  185. void mutt_tag_set_flag (int flag, int bf)
  186. {
  187.   int j;
  188.  
  189.   for (j = 0; j < Context->vcount; j++)
  190.     if (Context->hdrs[Context->v2r[j]]->tagged)
  191.       mutt_set_flag (Context, Context->hdrs[Context->v2r[j]], flag, bf);
  192. }
  193.  
  194. int mutt_thread_set_flag (HEADER *cur, int flag, int bf, int subthread)
  195. {
  196.   HEADER *start;
  197.   
  198.   if ((Sort & SORT_MASK) != SORT_THREADS)
  199.   {
  200.     mutt_error ("Threading is not enabled.");
  201.     return (-1);
  202.   }
  203.  
  204.   if (!subthread)
  205.     while (cur->parent)
  206.       cur = cur->parent;
  207.   start = cur;
  208.   
  209.   mutt_set_flag (Context, cur, flag, bf);
  210.   if ((cur = cur->child) == NULL)
  211.     return (0);
  212.   FOREVER
  213.   {
  214.     mutt_set_flag (Context, cur, flag, bf);
  215.     if (cur->child)
  216.       cur = cur->child;
  217.     else if (cur->next)
  218.       cur = cur->next;
  219.     else 
  220.     {
  221.       while (!cur->next)
  222.       {
  223.     cur = cur->parent;
  224.     if (cur == start)
  225.       return (0);
  226.       }
  227.       cur = cur->next;
  228.     }
  229.   }
  230.   /* not reached */
  231. }
  232.  
  233. int mutt_change_flag (HEADER *h, int bf)
  234. {
  235.   int i, flag;
  236.  
  237.   mvprintw (LINES - 1, 0, "%s flag? (D/N/O/r/*/!): ", bf ? "Set" : "Clear");
  238.   clrtoeol ();
  239.  
  240.   if ((i = mutt_getch ()) == ERR)
  241.   {
  242.     CLEARLINE (LINES-1);
  243.     return (-1);
  244.   }
  245.  
  246.   CLEARLINE (LINES-1);
  247.  
  248.   switch (i)
  249.   {
  250.     case 'd':
  251.     case 'D':
  252.       flag = M_DELETE;
  253.       break;
  254.  
  255.     case 'N':
  256.     case 'n':
  257.       flag = M_NEW;
  258.       break;
  259.  
  260.     case 'o':
  261.     case 'O':
  262.       if (h)
  263.     mutt_set_flag (Context, h, M_READ, !bf);
  264.       else
  265.     mutt_tag_set_flag (M_READ, !bf);
  266.       flag = M_OLD;
  267.       break;
  268.  
  269.     case 'r':
  270.     case 'R':
  271.       flag = M_REPLIED;
  272.       break;
  273.  
  274.     case '*':
  275.       flag = M_TAG;
  276.       break;
  277.  
  278.     case '!':
  279.       flag = M_FLAG;
  280.       break;
  281.  
  282.     default:
  283.       BEEP ();
  284.       return (-1);
  285.   }
  286.  
  287.   if (h)
  288.     mutt_set_flag (Context, h, flag, bf);
  289.   else
  290.     mutt_tag_set_flag (flag, bf);
  291.  
  292.   return 0;
  293. }
  294.